


#include <iostream>
#include <thread>
#include <future>
#include <vector>
#include <tuple>
#include <string>
#include "common.h"
#include <sstream>

using namespace std;

namespace THREAD_LOCK_DAY26
{
    std::mutex mtx; // 定义互斥量
    std::atomic<int> x(0); // 定义原子变量
    std::vector<int> data; // 定义数据容器

    void reader() {
        mtx.lock(); // 获取锁
        data.push_back(x.load(std::memory_order_relaxed)); // 读取原子变量的值
        
        for (auto i:data)
        {
            std::cout << i << std::endl;
        }
        mtx.unlock(); // 释放锁
    }

    void writer() {
        mtx.lock(); // 获取锁
        x.store(10, std::memory_order_release); // 修改原子变量的值
        
        for (auto i:data)
        {
            data[i] = x;
        }
        for (auto i:data)
        {
            std::cout << i << std::endl;
        }
        mtx.unlock(); // 释放锁
    }

};

namespace CONSTEXPR_DAY26
{
    constexpr int func(int i) {
        return i + 1;
    }
};

namespace ARGVS_TEMPLATE_DAY26
{
    template<typename T>
    std::string toString(const T& value) {
        std::ostringstream oss;
        oss << value;
        return oss.str();
    }

    template<typename T, typename... Args>
    std::string toString(const T& value, const Args&... args) {
        std::ostringstream oss;
        oss << value;
        return oss.str() + " " + toString(args...);
    }

    template<typename... Args>
    void myPrintf(const char* format, const Args&... args) {
        std::cout << toString(format, args...) << std::endl;
    }
};

namespace MOVE_DAY26
{
    // 移动语义,减少资源的拷贝
    class Person
    {
        public:
            Person() {
                std::cout << "默认构造函数" << std::endl;
                // 假设需要分配大量内存或进行其他资源密集型操作
            }

            Person(const Person& other) {
                std::cout << "拷贝构造函数" << std::endl;
                // 实现对象的拷贝操作
            }

            Person(Person&& other) {
                std::cout << "移动语义构造函数" << std::endl;
                // 实现对象的移动操作
            }
    };
};

namespace PERFECT_MOVE_DAY26
{
    template<typename F ,typename T, typename U>
    void testFun(F f, T && t1, U && t2)
    {
        f(std::forward<T>(t1),std::forward<U>(t2));
    }
    
    void gu_y(int && t1, int & t2) // 接收左值和右值
    {
        cout << t1+t2 << endl;
    }
};





int main()
{

    {
        __LOG__("内存模型、线程和锁、原子操作");
        using namespace THREAD_LOCK_DAY26;
        std::thread t1(reader); // 创建读线程t1
        std::thread t2(writer); // 创建写线程t2
        t1.join(); // 等待读线程结束
        t2.join(); // 等待写线程结束
    }

    {
        __LOG__("期值");
        // 创建一个异步任务
        std::future<int> fut = std::async(std::launch::async, [](){
            std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟耗时操作
            return 42; // 返回结果
        });

        // 在另一个线程中等待结果
        std::cout << "Result: " << fut.get() << std::endl; // 输出结果

        std::future<int> result;

        // 启动一个异步任务来计算两个数之和
        result = std::async(std::launch::async, [](int a, int b) {
            return a + b;
        }, 3, 4);

        // 在主线程中等待异步任务完成并获取结果
        int sum = result.get();
        std::cout << "两数之和为：" << sum << std::endl;
        
    }

    {
        __LOG__("变参模板");
        using namespace ARGVS_TEMPLATE_DAY26;
        myPrintf( "Alice", 30,23.8);
    }

    {
        __LOG__("移动语义(节约资源，提高效率)");
        using namespace MOVE_DAY26;
        Person person1;  // 调用默认构造函数

        Person person2(person1);  // 调用拷贝构造函数，拷贝 person1 的值到 person2
        Person person3(std::move(person1));  // 调用移动构造函数，将 person1 的值转移到 person3

    }

    {
        __LOG__("完美转发(兼顾左值和右值的同时使用)");
        using namespace PERFECT_MOVE_DAY26;
        int per1 = 23;
        int per2 = 34;
 
        cout << "左右: ";
        testFun(gu_y,23,per2);// 传入右值和左值
    }

    {
        __LOG__("lambda式,匿名函数");
        // 匿名函数
        auto add = [](int a, int b) -> int { return a + b; };
        int sum = add(3, 4);
        std::cout << "Sum: " << sum << std::endl;


        // lambda 式, 匿名函数
        auto swap = [](int & a, int & b) -> void {a=a^b;b=a^b;a=a^b;};

        int a = 12;
        int b = -78;

        std::cout << "a: " << a << " b: " << b << std::endl;
        swap(a,b);
        std::cout << "a: " << a << " b: " << b << std::endl;

        auto func = [=]{return (a+12);}; 
        a = func();

        std::cout << a << std::endl;

        auto func1 = [&](int x){std::cout << ++x << std::endl;};

        func1(a);
    }

    {
        __LOG__("别名(typedef 和 using)");
        // 别名
        typedef int myInt;
        myInt kp;

        using IntVector = std::vector<int>; 
        IntVector ki;
        ki.push_back(23);
        for (auto i : ki)
        {
            std::cout << i << std::endl;
        }

        using MYint = int;
        MYint lo = 4;
        std::cout << lo << std::endl;

    }

    {
        __LOG__("tuple");
        // tuple
        std::tuple<int, int, std::string> myTuple(1, 2, "hello");

        auto [value1, value2, value3] = myTuple;
        // 结构化绑定
        std::cout << value1 << " " << value2 << " " << value3 << " " << std::endl;


    }

    {
        // 范围for
        __LOG__("范围for");
        std::vector<int> myVector = {1, 2, 3, 4, 5};
        for (int num : myVector) {
            std::cout << num << std::endl;
        }
        for (auto num : myVector) {
            std::cout << num << std::endl;
        }

        
    }

    {
        __LOG__("使用花括号{}初始化捕获变量");
        int a = 10;
        int b = 20;
        [a, b]() mutable { // 使用花括号{}初始化捕获变量
            std::cout << "a: " << a << ", b: " << b << std::endl;
        }();

    }

    {
        __LOG__("constexpr(编译期间确定)");
        using namespace CONSTEXPR_DAY26;
        // constexpr
        int i = 2;
        func(i);// 普通函数
        func(2);// 编译期间就会被计算出来
    }


 
    
    return 0;
}



